Expanding physical motion gesture lexicon for an automated assistant

ABSTRACT

Implementations provided herein relate to correlating available input gestures to recently created application functions, and adapting available input gestures, and/or user-created input gestures, to be correlated with existing application functions. Available input gestures (e.g., a hand wave) can be those that can be readily performed upon setup of a computing device. When a user installs an application that is not initially configured to handle the available input gestures, the available input gestures can be correlated to certain functions of the application. Furthermore, a user can create new gestures for application actions and/or modify existing gestures according to their own preferences and/or physical capabilities. When multiple users elect to modify an existing gesture in the same way, the modification can be made universal, with permission from the users, in order to eliminate latency when subsequently adapting to preferences of other users.

BACKGROUND

Humans may engage in human-to-computer dialogs with interactive softwareapplications referred to herein as “automated assistants” (also referredto as “digital agents,” “chatbots,” “interactive personal assistants,”“intelligent personal assistants,” “assistant applications,”“conversational agents,” etc.). For example, humans (which when theyinteract with automated assistants may be referred to as “users”) mayprovide commands and/or requests to an automated assistant using spokennatural language input (i.e., utterances), which may in some cases beconverted into text and then processed, and/or by providing textual(e.g., typed) natural language input. Additionally, or alternatively, anautomated assistant can receive a request from a user via a physicalmotion gesture that is captured by a camera or other vision component.An automated assistant can respond to a physical motion gesture bycontrolling a corresponding smart device and/or providing responsiveuser interface output, which can include audible and/or visual userinterface output.

In some instances, a user may provide a physical motion gesture that,while intended by the user to cause performance of an automatedassistant action, does not result in performance of the intendedautomated assistant action. For example, the physical motion gesture maybe performed in a way that is not understandable by the automatedassistant and/or may be a physical motion gesture that is not explicitlymapped to any automated assistant action. As a result, the automatedassistant may be unable to fully process the physical motion gestureand/or can fail to determine that the gesture is a request for theautomated assistant action. This leads to the automated assistantproviding no response to the physical motion gesture, or providing onlyan error response, such as, “Sorry, I can't help with that” and/or anerror tone. Despite the automated assistant failing to perform theintended automated assistant action corresponding to the physical motiongesture—or otherwise not identifying any executable action associatedwith the physical motion gesture, various computer and/or networkresources are nonetheless consumed in processing the physical motiongesture and attempting to identify an appropriate action. For example,data corresponding to the physical motion gesture can be transmittedand/or undergo some amount of processing. Such consumption of resourcesis wasteful, since the intended action is not performed. Moreover, theuser will likely attempt to provide alternate user interface input(e.g., a spoken command, a touch input, or an alternate physical motiongesture) or another instance of the physical motion gesture in againseeking performance of the intended action. Such subsequent userinterface input will also have to be processed. This results inadditional processing being performed and results in latency inperformance of the action, as compared to if the user had insteadinitially provided a suitable physical motion gesture to the automatedassistant. Accordingly, there exists a desire to improve the efficiencyof physical motion gesture inputs.

SUMMARY

Implementations provided herein relate to correlating available inputgestures to newly provided application functions, and adapting availableinput gestures, and/or user-created input gestures, to be correlatedwith existing application functions. A recently created applicationfunction can correspond to an action that can be performed by anapplication that has been installed at a computing device, which did nothave the functionality to perform the action prior to the applicationbeing installed. Although the application function can be controlled viaone or more user inputs (e.g., as established by a manufacturer of theapplication), the application function may not be controllable via anyphysical motion gestures. For instance, the user can install a securityapplication on their home computing device, and the home computingdevice can also include a messaging application that the user typicallycontrols using a lateral hand swipe gesture. Such control of themessaging application can be useful when the user is not available todirectly touch an interface of the computing device, and/or has ahandicap that prevents them providing a spoken utterance to thecomputing device. The computing device can determine that the userfrequently uses the lateral hand swipe gesture, and also determine thatan application function (e.g., viewing alerts of the securityapplication) of the security application is not currently configured tobe controlled via the lateral hand swipe gesture. Based on thesedeterminations, the computing device can generate correlation data thatmaps the lateral hand swipe gesture to an application function of thesecurity application. Optionally, the user can be prompted to confirmthe mapping and/or otherwise be put on notice that the lateral handswipe gesture is available to control one or more functions of thesecurity application. This can allow the user to decide whether thegesture should be mapped to a function of the security application.

A particular gesture can be selected for mapping to a particularapplication function, and/or action, based on one or more differentcriteria. In some implementations, a gesture can be identified formapping to an application based on a frequency at which the userperforms the gesture relative to other gestures. Additionally, oralternatively, the gesture can be identified for mapping to anapplication based on how many times the user has performed the gesturesuccessfully. As an example, a computing device can determine that theuser performs a first gesture with a 90% success rate and a secondgesture with an 85% success rate, and based on these determinations, thefirst gesture can have priority when identifying a gesture to map to anapplication function. Therefore, after the user has installed aparticular application that includes multiple different applicationfunctions not immediately controllable via a gesture input, a particularapplication function (e.g., viewing alerts of a security application)that is being used most frequently can be identified. The mostfrequently used application function can then be mapped to the mostfrequently used and/or most successfully performed input gestureperformed by the user. Thereafter, interactions between the user and theparticular application can be analyzed in order to determine any otherapplication functions that should be mapped to other input gestures.

In some implementations, a “lexicon” (i.e., a set) of input gesturesavailable to a user can be expanded as a result of the user attemptinggestures that may be initially unfamiliar to the computing device and/oranother device that is tasked with responding to the gestures. When theuser attempts an input gesture for the first time, a computing devicecan recognize that the attempt by the user is a first attempt, andgenerate data for characterizing the input gesture. The data, with priorpermission from the user, can be compared to other data thatcharacterizes other input gestures performed by other users. The datacan be compared in order to determine whether the input gesture providedby the user has one or more characteristics in common with any gestureof the other input gestures. For example, the data can characterize theinput gesture as having at least an elbow-swinging motion, and the otherdata can characterize at least one other gesture as also having at leastan elbow-swinging motion. In response to determining that the inputgesture and the other gesture have at least one characteristic incommon, the user can be prompted, at an interface of a computing device,to confirm whether the input gesture, which the user attempted,corresponds to the other input gesture that has been identified. Theprompt can be provided at a graphical interface and include a graphicaldepiction of the other input gesture. Additionally, or alternatively,the prompt can include a textual description of the other input gesture,and, optionally, the one or more trained machine learning models can beused to generate the textual description (e.g., based on image(s),audio, and/or video(s) of the other input gesture). The prompt cancorrespond to a request for the user to confirm whether the userintended the input gesture to be an imitation of the other inputgesture.

Should the user confirm that they intended the input gesture to imitatethe other input gesture that was identified, an application functionthat is controllable via the computing device can be identified as beingcorrelated to another application function that the other input gesturecontrolled. Based on the identified correlation, the applicationfunction can be configured at the computing device such that theapplication function is controllable via the input gesture. Thecorrelation can be identified based on the other application functionand the application function having one or more parameters, and/or oneor more parameters values, in common. For instance, the otherapplication function can be a “browser refresh” function, and aparameter of the other application function can include a “name” of thebrowser to be refreshed. Furthermore, the application function can be a“website refresh” function, which can also have a parameter thatincludes the “name” of a browser to be refreshed. Therefore, based onthis shared parameter, the application function and the otherapplication function can be considered correlated, and the input gesturecan be mapped to the application function.

In some implementations, should the user not confirm that they intendedthe input gesture to imitate the other input gesture, one or moreapplication functions that are controllable via the computing device canbe identified. Based on the input gesture having not been previouslyperformed by the user, the user can be prompted to select a particularapplication function, from the one or more application functions, to bemapped to the input gesture. This can allow the user to expand a“lexicon” of the computing device and/or an application, at least withrespect to how many gestures the computing device and/or the applicationcan be responsive. When the user has selected a particular applicationfunction, the user can optionally be prompted to provide anotherinstance of the input gesture for confirming the exact input gesturethat is to be mapped to the particular application function.Furthermore, by generating additional data related to another instanceof the input gesture, the additional data can be used for training oneor more machine learning models that will process inputs that are basedon various input gestures from the user.

In other implementations, a user can assign an input gesture to controlan action of an application by performing the input gesture one or moretimes, in order to “hint” to their respective computing device that theywould like the input gesture to be recognized by the computing device.Furthermore, the user can cause the action of the application to beperformed within some time period of performing the input gesture one ormore times. As an example, the user can initialize their stove topburners to boil water, and the oven can have an integral computingdevice that is connected, via a local area network, to home computingdevice that includes a camera interface. The user can desire that theirstove top burners be controllable via one or more hand gestures thatinclude a “stop” hand gesture, which can correspond to the userextending their hand out flat in front of them. In order to initializesuch a configuration, the user can perform the “stop” hand gesture, suchthat the “stop” hand gesture is captured by the home computing device,while the oven burner is actively boiling a pot of water. In otherwords, the home computing device and/or the oven have not previouslybeen configured to be responsive to the “stop” hand gesture, and thehome computing device may not be responsive to the “stop” handgesture—but, regardless, the home computing device can capture imagedata corresponding to the “stop” hand gesture (with prior permissionfrom the user).

Thereafter, or before performing the “stop” hand gesture, the user canturn off the oven burner. The home computing device can determine thatthe user performed the “stop” hand gesture within a period of time ofturning off the oven burner, and provide a request for the user toconfirm whether the user would like the “stop” hand gesture to controlthe oven burner. Should the user confirm that they intended the “stop”hand gesture to control the oven and/or turn off the oven burner, thehome computing device can cause data to be generated for indicating thatthe oven is to be controllable via an instance of the physical motiongesture. In other words, the home computing device can communicate withthe oven and/or a server device to establish a setting that allows theoven to be responsive to the home computing device (and/or any othercomputing device associated with the user) determining that the userperformed the “stop” hand gesture.

In some implementations, in order for the user to configure theircomputing device(s) to be responsive to an input gesture that they hadnot been previously used to control an action of an application and/or acomputing device, one or more initial instances of the input gesture canbe captured. Data characterizing the user performing the input gesturecan be compared to other data associated with one or more input gesturesthat were already available for the user to perform. The other data cancharacterize a set of input gestures that were available for the user toperform since they initially setup their home computing device and/orinstalled one or more applications at the home computing device.Additionally, or alternatively, the other data can characterize the setof input gestures and/or one or more other inputs gestures that one ormore other users have performed. For example, the one or more otherinput gestures can be supplemental input gestures that were notinitially available to one or more other users, until those one or moreother users created the one or more other input gestures. Therefore,when the user initially performs an input gesture for the first time,the data characterizing the input gesture can be used to determinewhether the input gesture corresponds to an existing gesture, which canincludes gestures within an initial set of gestures and/or within thesupplemental input gestures created by other users. When the inputgesture is determined to not correspond to any gesture of the initialset of input gestures and/or the supplemental input gestures created byother users, the user can be prompted with a request to establish anentirely new input gesture. The new input gesture can then be correlatedto one or more actions of an application(s) and/or a computingdevice(s), as indicated by the user, and/or as suggested by anapplication(s) and/or a computing device(s).

The above description is provided as an overview of some implementationsof the present disclosure. Further description of those implementations,and other implementations, are described in more detail below.

In some implementations, a method implemented by one or more processorsis set forth as including operations such as processing image data,captured via a camera interface of a computing device, whichcharacterizes a physical motion gesture has been provided by a user to acomputing device, wherein the computing device is controllable via thephysical motion gesture and an application, which is accessible via thecomputing device, is currently unresponsive to the physical motiongesture. The method can further include determining that theapplication: includes an application function that is being used by theuser, and that the application function is not responsive to thephysical motion gesture provided by the user to the camera interface ofthe computing device. The method can further include causing, based ondetermining that the application function is not responsive to thephysical motion gesture, correlation data to be generated forcorrelating the physical motion gesture to the application function infurtherance of allowing the user to control the application function ofthe application via the physical motion gesture. The method can furtherinclude determining, subsequent to generating the correlation data,whether the user has performed the physical motion gesture infurtherance of controlling the application function of the application.The method can further include, when the user is determined to haveperformed the physical motion gesture subsequent to the correlation databeing generated, causing, in response to determining that the userperformed the physical motion gesture, the application function to becontrolled via the application.

In some implementations, the application function is not directlyexecutable via the computing device without the application executing atthe computing device. In some implementations, the method can furtherinclude causing, prior to the correlation data being generated, a promptto be provided at the computing device requesting that the user confirmcorrelating the physical motion gesture to the application function ofthe application. In some implementations, determining that theapplication includes the application function that is being used by theuser includes: determining that the physical motion gesture has beenperformed by the user more frequently than the user has performed atleast one other physical motion gesture. In some implementations, thatthe application includes the application function that is being used bythe user includes: determining that the physical motion gesture has beenperformed more accurately by the user than another user has performedthe physical motion gesture at a different computing device. In someimplementations, determining that the application includes theapplication function that is being used by the user includes:determining that the user has controlled multiple different applicationfunctions of the application, wherein the multiple different applicationfunctions include the application function, and determining that theapplication function of the multiple different applications has beencontrolled, by the user, more frequently relative to other applicationfunctions of the multiple different application functions have beencontrolled by the user. In some implementations, the method can furtherinclude determining, subsequent to generating the correlation data, thata separate application function of the application is not currentlyresponsive to a particular motion gesture that is different from thephysical motion gesture; and causing, based on determining that theseparate application function of the application is not currentlyresponsive to the particular motion gesture, other correlation data tobe generated for correlating the particular motion gesture to theseparate application function in furtherance of allowing the user tocontrol the separate application function of the application via theparticular motion gesture. In some implementations, the method canfurther include determining, prior to determining that the applicationincludes the application function that is being used by the user, thatthe user has controlled the application function of the application morefrequently than the user has controlled the separate applicationfunction.

In other implementations, a method implemented by one or more processorsis set forth as including operations such as determining, based on datagenerated in response to a gesture input to a computing device, that auser has performed a particular gesture that the user has not previouslyprovided as an input to the computing device. The method can furtherinclude determining, based on the data, that a separate gesture inputwas previously provided a separate computing device by a different user,and that the separate gesture input has one or more characteristics incommon with the gesture input provided by the user to the computingdevice, wherein the separate gesture input was previously provided tothe separate computing device to control an application function of theseparate computing device. The method can further include causing, inresponse to determining that the separate gesture input has one or morecharacteristics in common with the gesture input, an interface of thecomputing device or another computing device to provide a request to theuser to confirm whether the user intended the gesture input to imitatethe separate gesture input. The method can further include, when, inresponse to causing the interface of the computing device or the othercomputing device to provide the request to the user, the user confirmsthey intended the gesture input to imitate the separate gesture input:determining that another application function is controllable via thecomputing device and that the other application function includes acommon feature to the application function, and causing the applicationfunction to be controllable via an instance of the gesture input.

In some implementations, the method can further include, when, inresponse to causing the interface of the computing device or the othercomputing device to provide the request to the user, the user indicatesthey did not intend the gesture input to imitate the separate gestureinput: identifying one or more applications functions that arecontrollable via the computing device, and prompting the user to selecta particular application function of the one or more applicationfunctions to be controllable via the gesture input. In someimplementations, the method can further include, when, in response tocausing the interface of the computing device or the other computingdevice to provide the request to the user, the user indicates they didnot intend the gesture input to imitate the separate gesture input:determining, that the user has selected the particular applicationfunction of the one or more application functions to be controllable viathe gesture input, and causing the interface of the computing device orthe other computing device to provide another request for the user toperform another instance of the gesture input. In some implementations,the common feature is a common parameter, and causing the applicationfunction to be controllable via the instance of the gesture inputincludes causing a parameter value to be assigned to the commonparameter when the user subsequently performs the instance of thegesture input. In some implementations, determining that anotherapplication function is controllable via the computing device includes:identifying an application, from multiple different applications, thatthe user has previously controlled without providing a physical motiongesture to a camera interface of the computing device, and determiningone or more different application functions that are controllable viathe application, wherein the one or more different application functionsinclude the application function.

In yet other implementations, a method implemented by one or moreprocessors is set forth as including operations such as determining,based on processing image data captured via a camera interface of acomputing device from which one or more applications are accessible,that a user has performed a physical motion gesture one or more times,wherein the one or more applications are responsive to other physicalmotion gestures and the one or more applications are currentlyunresponsive to the physical motion gesture. The method can furtherinclude determining that the user has caused an action to be performed:via an application of the one or more applications, and within a periodof time of the user performing the physical motion gesture one or moretimes. The method can further include causing, in response todetermining that the user caused the action to be performed via theapplication, an interface of the computing device or another computingdevice to provide a request to the user to confirm whether the userintended the physical motion gesture to control the action performed viathe application. The method can further include, when, in response tocausing the interface of the computing device or the other computingdevice to provide the request to the user, the user confirms theyintended the physical motion gesture to control the action performed bythe application: generating control data that indicates the actionperformed by the application is controllable via an instance of thephysical motion gesture.

In some implementations, determining that the user has performed thephysical motion gesture one or more times includes: determining that theimage data, and/or gesture data characterizing the performance of thephysical motion gesture by the user, is associated with other data thatcorresponds to a particular physical motion gesture of one or more otherphysical motion gestures. In some implementations, the particularphysical motion gesture is associated with another user that configuredanother computing device and/or another application to be responsive tothe particular physical motion gesture. In some implementations, theother data, which corresponds to the particular physical motion gesture,is generated based on each user, of multiple different users, performingan instance of the particular physical motion gesture. In someimplementations, the period of time is based on: an action typecorresponding to the action performed via the application, and/or anapplication type corresponding to the application. In someimplementations, the request to confirm whether the user intended thephysical motion gesture to control the action performed via theapplication includes providing a request for the user to perform anotherinstance of the physical motion gesture in order to indicateconfirmation. In some implementations, the method can further includeidentifying another function of the application that is not currentlyresponsive to another physical motion gesture captured via the camerainterface of the computing device; and when the user confirms theyintended the physical motion gesture to control the action performed bythe application: causing the interface of the computing device toprovide another request for permission from the user to allow the otherfunction to be controllable via the other physical motion gesture.

In other implementations, a method implemented by one or more processorsis set forth as including operations such as determining, based onprocessing image data captured via a camera interface of a computingdevice from which one or more applications are accessible, that a userhas performed a physical motion gesture one or more times, wherein theone or more applications are responsive to other physical motiongestures and the one or more applications are currently unresponsive tothe physical motion gesture. The method can further include determiningthat the user has caused an action to be performed: via an applicationof the one or more applications, and within a period of time of the userperforming the physical motion gesture one or more times. The method canfurther include generating control data that indicates the actionperformed by the application is controllable via an instance of thephysical motion gesture.

Other implementations may include a non-transitory computer readablestorage medium storing instructions executable by one or more processors(e.g., central processing unit(s) (CPU(s)), graphics processing unit(s)(GPU(s)), and/or tensor processing unit(s) (TPU(s)) to perform a methodsuch as one or more of the methods described above and/or elsewhereherein. Yet other implementations may include a system of one or morecomputers and/or one or more robots that include one or more processorsoperable to execute stored instructions to perform a method such as oneor more of the methods described above and/or elsewhere herein.

It should be appreciated that all combinations of the foregoing conceptsand additional concepts described in greater detail herein arecontemplated as being part of the subject matter disclosed herein. Forexample, all combinations of claimed subject matter appearing at the endof this disclosure are contemplated as being part of the subject matterdisclosed herein.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1A, FIG. 1B, and FIG. 1C include views of a user configuring anapplication to be responsive to a physical motion gesture that the userhas previously employed to control one or more device and/or applicationfunctions.

FIG. 2A, FIG. 2B, and FIG. 2C illustrate views of a user configuring acomputing device and/or an application to be responsive to a physicalmotion gesture by performing the physical motion gesture within a timeperiod of controlling a function of the computing device and/or theapplication.

FIG. 3 illustrates a system for correlating available input gestures tonewly provided functions, and adapting available input gestures, and/oruser-created input gestures, to be correlated with existing functions.

FIGS. 4A and 4B illustrate methods for mapping one or more physicalmotion gestures to one or more functions, accessible via one or moredevices and/or one or more applications.

FIG. 5 is a block diagram of an example computer system.

DETAILED DESCRIPTION

FIG. 1A, FIG. 1B, and FIG. 1C include view 100, view 120, and view 150,respectively, of a user 106 configuring an application to be responsiveto a physical motion gesture 104 that the user 106 has previouslyemployed to control one or more device and/or application functions.Specifically, FIG. 1A provides a view 100 of a user performing thegesture 104 while a movie application 110 is executing at a firstcomputing device 102, and FIG. 1A and FIG. 1B provide view 120 and view150, respectively, of a second computing device 134 guiding the user 106to configure a call application 124 to also be responsive to the gesture104.

FIG. 1A illustrates a view 100 of the user 106 watching a movie that isbeing provided by a movie application 110, and being rendered by a firstcomputing device 102. The movie application 110 can be an applicationthat is installed by a manufacturer of the first computing device 102,installed by the user 106, and/or otherwise accessible via the firstcomputing device 102 and/or over a network, such as the internet. Themovie application 110 can be responsive to one or more physical motiongestures capable of being performed by the user 106.

The movie application 110 can determine and that the user is performinga particular gesture based on image data captured via a camera of thefirst computing device 102. For example, the first computing device 102can be disposed within a room 114, and a camera that is attached to thefirst computing device 102 can be directed (as setup by the user 106)into a direction of the user 106, when the user is viewing the firstcomputing device 102. In this way, the user 106 is able to controlvarious functions and/or actions of the first computing device 102, themovie application 110, and/or any other application that is accessibleto the first computing device 102, using physical motion gestures.

As an example, the movie application 110 can be responsive to a gesture104, in which the user raises their hand 112 away from their body, andopens their palm towards the camera of the first computing device 102.For clarity, a perspective view 108 is provided as a close up of thegesture 104 being performed by the user 106. Furthermore, element “A” isillustrated for purposes of indicating a direction 118 from which theperspective view 108 is based. The first computing device 102 cangenerate image data capturing the gesture 104, and the movie application110 can determine, based on processing of the image data, that the userhas performed a particular gesture that controls a particular functionof the movie application 110. Specifically, the gesture 104 can be a“pause” gesture, and when the movie application 110 is playing a movie,detection of the “pause” gesture can cause playback of the movie topause. Although the user 106 may frequently use this gesture 104 withrespect to the movie application 110, the user 106 can be provided withsuggestions for allowing other functions to be controllable via thegesture 104. Alternatively, or additionally, the user 106 can configureone or more of their devices and/or applications to be controllable viathe gesture 104 without having previously been suggested such aconfiguration.

In some implementations, the first computing device 102, a serverdevice, and/or an application that is accessible via the first computingdevice 102 and/or the server device, can determine that the gesture 104is performed most frequently by the user 106, at least relative to oneor more other gestures previously performed by the user. Based on thisdetermination, the gesture 104 can be the subject of one or moredifferent suggestions that can be provided to the user 106 when they areinteracting with one or more devices and/or one or more applications.Alternatively, or additionally, the gesture 104 can be selected as thesubject of one or more suggestions based on the user 106 havingperformed the gesture 104 successfully and/or accurately more times thanthe user 106 has performed, or attempted to perform, one or more othergestures.

FIG. 1B illustrates a view 120 of the user 106 interacting with a callapplication 124 using a computing device 134. While operating the secondcomputing device 134, the second computing device 134 and/or the callapplication 124 can cause a suggestion 128 to be provided to the user106. The suggestion 128 can be generated and/or provided at an interface122 of the call application 124 when the user 106 is controlling afunction of the call application 124 and/or when the call application124 is operating according to a particular state. As an example, thesuggestion 128 can be provided at a display panel 132 of the secondcomputing device 134 in response to the user 106 initializing a call 126via a call function of the call application 124. The call application124, the first computing device 102, the second computing device 134, anautomated assistant, and/or the server device can determine that thecall function is a function of the call application 124 that the user106 most frequently uses relative to other functions of the callapplication 124. Therefore, a suggestion 128 can be provided in anattempt to allow the user 106 to correlate a most frequently usedfunction of one application with a most frequently used physical motiongesture that the user 106 employs to control when interacting with adifferent application. In order to further clarify the suggestion, thesuggestion 128 can include text such as “Tap here, or say ‘select,’ toset the ‘pause’ gesture, used with your ‘Movie Application,’ to alsocontrol a ‘mute microphone’ function of the ‘Call Application.’”

By providing the user 106 with the opportunity to configure a mutemicrophone function of the call application 124 to be responsive to thegesture 104 that the user 106 is already familiar with, interactionsbetween the user 106 and the call application 124 can be streamlined.The user may thus submit commands to a respective computing device whichare more efficiently handled. In this way, interaction time between theuser 106 and a respective computing device can be decreased, therebypreserving computational resources and power resources, such as batterylife. For example, when it is not convenient for the user 106 to performsome manual touch gesture at the display panel 132 (e.g., the user 106is in a kitchen, and has dough on their hands) to control a particularfunction, the user 106 would be able to control that particular functionusing whichever physical motion gesture of their choosing via a cameraof the second computing device 134.

In order to configure the call function to be controllable via thegesture 104, the user can select the suggestion 128 by tapping thedisplay panel 132 at the graphical element representing the suggestion128. Alternatively, or additionally, the user 106 can provide a spokenutterance 138, indicating their permission to use the gesture 104 tocontrol the mute microphone function of the call application 124. Themute microphone function can control whether a recipient of a call canhear the user 106, and an operating status of the mute microphonefunction can be optionally indicated by an icon 130. For instance, asprovided in FIG. 1B, the user 106 can explicitly indicate therewillingness to configure the mute microphone function to be controllablevia the gesture 104 by providing the spoken utterance 138, “Select!”

In response to the user indicating their willingness to configure themute microphone function to be controllable via the gesture 104, thecall application 124 can thereafter be configured to be responsive tosubsequent instances of the gesture 104. For example, as illustrated inview 150 of FIG. 1C, the user 106 can invoke a call function of the callapplication 124, thereby causing an interface 122 of the callapplication 124 to indicate a call status 152 of the call application124. During the call, the user 106 can perform the gesture 104 usingtheir hand 158. A camera 160 can capture the gesture 104 by providing anoutput, which can be used to generate image data, and the image data canthen be processed in order to verify that the gesture 104 was performedby the user 106. FIG. 1C provides a perspective view 162 of the user 106performing the gesture 104, and the perspective view 162 can be relativeto a viewpoint indicated by element “B.”

In response to determining that the user 106 performed the gesture 104,the mute microphone function of the call application 124 can beexecuted. Furthermore, in response to the gesture 104, an updated statusicon 156 can be provided at the interface 122 of the call application124. Alternatively, or additionally, a graphical element 154 can beprovided at the display panel 132 and indicate that the pause gesturehas been acknowledged. By executing the “mute microphone” function, themicrophone of the second computing device 134 can be temporarily mutedwhile the “Call with Matthew” is ongoing.

In some implementations, as the user 106 continues to use the callapplication 124, and/or any other application that can be accessible toa computing device, a frequency of each function of an application canbe determined at various points and/or periodically. Specifically, afrequency of usage of each function that is not currently correlated toa physical motion gesture can be determined at various points and/orperiodically. Therefore, when a most frequently used function iscorrelated to a physical motion gesture, a most frequently used functioncan be identified for suggesting another physical motion gesture forcorrelating to the next most frequently used function. This process canrepeat until multiple different functions of multiple differentapplications and/or devices that are accessible to a computing deviceare controllable via one or more different physical motion gestures thatcan be captured via a camera interface of the computing device.Furthermore, additional physical motion gestures can be created by theuser 106, in order to provide even more functionality and/orresponsiveness to one or more devices and/or one or more applications.

FIG. 2A, FIG. 2B, and FIG. 2C illustrate a view 200, a view 220, and aview 230, respectively, of a user 206 configuring a computing deviceand/or an application to be responsive to a physical motion gesture byperforming the physical motion gesture within a time period ofcontrolling a function of the computing device and/or the application.Specifically, FIG. 2A illustrates the user 206 performing a gesture 204that they would like a second computing device 202 to be responsive to,despite the second computing device 202 not currently being responsiveto the gesture. FIG. 2B illustrates the user 206 controlling thefunction (e.g., turning on an oven light 212) that the user 206 wouldlike the gesture 204 to control, and FIG. 2C illustrates the user 206performing the gesture 204, and thereby effectively controlling thefunction of the second computing device 202.

As illustrated in FIG. 2A, the user 206 can walk into a room 210, suchas a kitchen, and perform a gesture 204 in order to indicate that theuser 206 would like the gesture 204 to control a particular function.The gesture 204 can be one that is already used by the user 206 tocontrol one or more other functions of a computing device and/or anapplication. Alternatively, the gesture 204 can be one that the user 206has not already used to control any function of a computing deviceand/or an application. Using prior permission from the user 206, a firstcomputing device 208 can capture image data, using a camera interface,of the user 206 performing the gesture 204.

The image data can be captured with prior permission from the user 206,and be processed in order to identify any gestures that may have beenperformed by the user 206. Alternatively, or additionally, the imagedata can be stored temporarily at the first computing device 208, and beprocessed in response to determining that the user 206 has controlledsome function of an application and/or a device within a period of timeof performing the gesture 204. For example, preliminary processing canbe performed on the image data to determine whether analready-established gesture has been performed, and if not, the imagedata can be stored temporarily, with permission from the user, shouldfurther processing be necessary. If the image data is stored withouthaving previously determined that the image data captured any gesture,and the user 206 is determined to have previously or subsequentlycontrolled a particular function, the image data can be furtherprocessed to identify whether the user performed any physical motionthat could be characterized as an actionable gesture.

FIG. 2B illustrates the user 206 performing a direct touch input 216 atthe second computing device 202, thereby controlling a function of thesecond computing device 202, such as a “turn on” oven light 212function. The user 206 can perform the direct touch input 216 before orafter performing the gesture 204 in FIG. 2A. In some implementations,the second computing device 202 can be an IoT device that is connectedover a local area network to which the first computing device 208, andoptionally, a third computing device 214 are also connected to.Therefore, with permission from the user 206, the first computing device208 can access data characterizing operational properties of the secondcomputing device 202 and the third computing device 214. For instance,an application for controlling the second computing device 202 can beaccessible via the first computing device 208, and an application thatis executing at the third computing device 214 can also be accessiblevia the first computing device 208.

In response to the user performing the direct touch input 216, the firstcomputing device 208 can determine that the oven light 212 of the secondcomputing device 202 has been turned on. Based on this determination,the first computing device 208, and/or another computing device that isassociated with the first computing vice 208, can perform furtherprocessing on image data characterizing the gesture 204, with priorpermission from the user 206. Processing of the image data can result inthe first computing device 208 determining that the user performed thegesture 204 one or more times within a time period of the user providingthe direct touch input 216 and/or otherwise controlling a function ofthe second computing device 202.

The time period can be a threshold time period that is static ordynamic, and/or can be based on the context of the user 206, the type ofgesture performed, the type of function controlled, the type of devicethat captured the gesture via a camera interface, and/or any otherfeature from which a time period can be based. For example, a thresholdtime period within which the user 206 should perform a gesture andcontrol a function, in order to have the gesture and function the mappedtogether, can be based on what amount of time that the function affectsa status of an application and/or a device. In some implementations, thethreshold time period can be directly proportional or inverselyproportional to the amount of time that the function affects the statusof the application and/or the device. For example, a threshold periodtime for mapping a gesture for preheating an oven can be smaller than athreshold period of time before mapping a gesture to the third computingdevice 214 for rendering an audible weather report. This difference inthe threshold period of time can be based on the assumption thatpreheating the oven will take much longer then providing the weatherreport.

In some implementations, when the first computing device 208, and/oranother computing device, determines that the user 206 controlled afunction of the second computing device 202 within a threshold timeperiod of performing the gesture 204, the first computing device 208 canoptionally prompt the user regarding mapping the gesture 204 to thefunction. For example, the first computing device 208 can render anaudio output 218 such as, “would you like the gesture to control theoven light?” In response, the user of 206 can provide a spoken utterancesuch as, “Yes, please.” The spoken utterance 222 can be received by thefirst computing device 208 and/or the third computing device 214, withpermission from the user, and can be processed to confirm that the user206 would like the gesture 204 to be mapped to the function of thesecond computer device 202. In other words, the first computing device208, or another computing device, can use data that identifies thegesture and data that identifies the function (controlling the ovenlight) and generate a natural language output as a query to the user206, in order to confirm the mapping of the gesture 204 to the function.

FIG. 2C illustrates a view 230 of the user 206 performing the gesture204, and, as a result, causing the oven light 212 of the secondcomputing device 202 to turn on. Specifically, performance of thegesture 204 by the user 206 can be captured via a camera interface ofthe first computing device 208. Image data captured by the camerainterface can be processed in order to determine that the user performedat the gesture 204. The first computing device 208 can then determinethat the gesture 204 was successfully mapped to the function of turningon the oven light 212, and, in response, cause the oven light 212 toturn on.

In some implementations, the user 206 can indicate an interest in havinga particular gesture mapped to a particular function of a device and/oran application, and the user 206 can be provided with suggestionsregarding mapping other gestures to other functions. For example, inresponse to the user 206 confirming that they would like the gesture 204to be mapped to the “turn on” oven light function, the first computingdevice 208 can identify other computing devices that are located in theroom 210. Furthermore, the first computing device 208 can identify oneor more functions of the other computing devices in the room 210 thathave not been mapped to one or more particular gestures.

For example, the first computing device 208 can determine that the thirdcomputing device 214 provides access to a music application that theuser 206 has frequently used. Furthermore, the first computing device208 can determine that a “next song” function is not currently mapped toa physical motion gesture. Based on this determination, the firstcomputing device 208 can render an audible suggestion such as, “Wouldyou like the gesture to control a ‘next song’ function of the musicapplication when the music application is executing at the thirdcomputing device?” The user 206 can confirm the mapping of the gesture204 to the music application function, thereby causing the gesture 204to control the music application when the music application is executingat the third computing device 214, and control the second computingdevice 202 when the music application is not executing at the thirdcomputing device 214. Alternatively, the rendered suggestion of thefirst computing device 208 can identify another gesture that isdifferent from the gesture 204 to be mapped to the “next song” functionof the music application. The other gesture can be identified based ondata that characterizes gestures that other users have used to control a“next song” function of their respective music application.

FIG. 3 illustrates a system 300 for correlating available input gesturesto newly provided application functions, and adapting available inputgestures, and/or user-created input gestures, to be correlated withexisting application functions. In some implementations, an automatedassistant 308, which is accessible via another computing device 338,and/or via any other application or apparatus, can be responsive to oneor more gestures. The automated assistant 308 can operate as part of anautomated assistant application that is provided at one or morecomputing devices 302 and/or other computing device(s) 338. A user caninteract with the automated assistant 308 via one or more assistantinterfaces 304, which can include one or more of a microphone, a camera,a touch screen display, a user interface, and/or any other apparatuscapable of providing an interface between a user and an application. Forinstance, a user can initialize the automated assistant 308 by providinga verbal, textual, physical motion, and/or a graphical input to theassistant interface to cause the automated assistant 308 to perform afunction (e.g., provide data, control a device (e.g., control an IoTdevice), access an agent, modify a setting, control an application(s),etc.). The computing device 302 can include a display device, which canbe a display panel that includes a touch interface for receiving touchinputs. The computing device 302 can also include a camera for capturingphysical motion gestures, thereby allowing a user to controlapplications of the computing device 302 via the camera interface. Thetouch inputs and/or other gestures (e.g., spoken utterances, physicalmotion gesture captured by the camera interface) can also allow a userto interact with the automated assistant 308, and/or any otherapplication that can be accessible via a computing device.

In some implementations, the computing device 302 can lack a displaydevice but include an audio interface (e.g., a speaker and/or amicrophone), thereby providing an audible user interface output, withoutproviding a graphical user interface output, as well as providing a userinterface, such as a microphone, for receiving spoken natural languageinputs from a user. For instance, in some implementations, the computingdevice can include one or more tactile input interfaces, such as one ormore buttons, and omit a display panel that would be provided graphicaldata from a graphics processing unit (GPU).

The computing device 302 can be in communication with a server deviceover a network, such as the internet. The computing device 302 canoffload computational tasks to the server device in order to preservecomputational resources at the computing device 302. For instance, theserver device can host an automated assistant, and the computing device302 can transmit inputs received at one or more assistant interfaces,and/or a user interface, to the server device. However, in someimplementations, the automated assistant 308 can be hosted at thecomputing device 302. In various implementations, all or less than allaspects of the automated assistant 308 can be implemented on the serverdevice and/or the computing device 302. In some of thoseimplementations, aspects of the automated assistant 308 are implementedvia a local automated assistant and interface with the server device,which can implement other aspects of the automated assistant 308. Theserver device can optionally serve a plurality of users and theirassociated assistant applications via multiple threads. Inimplementations where all or less than all aspects of the automatedassistant 308 are implemented via a local automated assistant of thecomputing device 302, the local automated assistant can be anapplication that is separate from an operating system of the computingdevice 302 (e.g., installed “on top” of the operating system)—or canalternatively be implemented directly by the operating system of thecomputing device 302 (e.g., considered an application of, but integralwith, the operating system).

In some implementations, the automated assistant 308 can include aninput processing engine 312, which can employ multiple different enginesfor processing inputs and/or outputs for computing device 302. Forinstance, the input processing engine 312 can include a gestureprocessing engine 314 that can process image data and/or audio datareceived at an assistant interface 304 to identify a request intended bya user that has performed a gesture. The data can be transmitted from,for example, the computing device 302 to the server device in order topreserve computational resources at the computing device 302.

The process for interpreting image data as a gesture, corresponding toan actionable request, can include an image recognition algorithm, whichcan employ one or more trained machine learning models 328, and/orstatistical models for identifying groups of pixel data corresponding toparticular objects and/or physical motions. Information derived from theimage data can be parsed by a data parsing engine 316 and made availableto the automated assistant 308 as assistant data 322, which can be usedto generate and/or identify requests from the user. In someimplementations, output data provided by the data parsing engine 316 canbe provided to an action engine 318 to determine whether the user hasprovided an input gesture that corresponds to a particular action,function, and/or routine capable of being performed by the automatedassistant 308, an application, an agent, and/or device that is capableof being accessed via the computing device 302. For example, assistantdata 322 can be stored at the server device and/or the computing device302, and can also include data that defines one or more actions capableof being performed by the automated assistant 308 and/or the computingdevice 302, as well as parameters involved in performing those actions.

When the input processing engine 312 has determined that a user hasrequested a particular action or routine be performed, the action engine318 can determine one or more parameter values for the particular actionor routine, and an output generating engine 320 can then provide anoutput to the user based on the particular action, routine, and/or theone or more parameters (or otherwise control a function(s) according tothe parameter value(s)). For instance, in some implementations, inresponse to a user input, such as a gesture directed at the assistantinterface 304, the automated assistant 308 can cause data, whichcharacterizes the gesture, to be transmitted to the server device fordetermining the action that the user is intending the automatedassistant 308 to perform. When the gesture corresponds to a request forcontrolling a particular Tot device, the output generating engine 320can cause an output to be provided to the user, via the assistantinterface 304, indicating a result of an action performed by the IoTdevice.

In some implementations, various gestures identified by the gestureprocessing engine 314 can be captured at one or more assistantinterfaces 304, and can include voice input, motion gestures, touchgestures, two-dimensional motion gestures, three-dimensional motiongestures, and/or any other gestures that can be identified by acomputing device. In some implementations, the computing device 302 canbe connected over a network 336 with one or more other computing device338, which can include one or more input device 340, and one or moreoutput device 342, respectively. The computing device 302 can storeand/or access application data 334 that characterizes one or moreapplications that can be accessible to the other computing device(s)338. Furthermore, a gesture mapping engine 332 of the computing device302 can access the application data 334 in order to identify one or morefunctions of the one or more applications have are currentlycontrollable via one or more gesture inputs.

When the gesture mapping engine 332 identifies a particular applicationfunction is not mapped to a particular gesture, or otherwise notconfigured to be controllable via a user input gesture, the gesturemapping engine 332 can communicate data, identifying the particularapplication function, to a suggestion engine 330. The suggestion engine330 can use the identified application function in order to generate asuggestion for the user regarding using a particular physical motiongesture to control the identified application function. The suggestionengine 330 can select a particular physical motion gesture to recommendto the user by identifying, based on client data 306 stored at thecomputing device 302 or otherwise accessible via the computing device302, one or more physical motion gestures that the user already employsto control one or more other functions.

In some implementations, the suggestion engine 330 can determine thephysical motion gesture that the user performs most frequently, andrecommend that the most frequently used physical motion gesture bemapped to the identified function that is not currently mapped to agesture. Additionally, or alternatively, the suggestion engine 330 candetermine the physical motion gesture that the user performs mostaccurately, relative to other physical motion gestures that the userperforms. For example, a physical motion gesture that the user performsmost accurately can be one that the computing device 302 has promptedthe user to repeat the least. In other words, the gesture processingengine 314 can prompt the user to re-perform a gesture when the user hasattempted to perform a physical motion gesture but, although the attemptwas acknowledged by the automated assistant 308, the physical motiongesture did not result in an action being performed. Therefore, thesuggestion engine 330 can determine a physical motion gesture that theuser has performed most accurately, and thus with a least frequentlyamount of “corrective” re-performances, in order to provide a suggestionof a physical motion gesture to map to the identified applicationfunction. Additionally, or alternatively, the computing device 302 candetermine that the identified function shares one or more parameters(e.g., function([parameter_1], [parameter_2], . . . [parameter_n]) witha certain application function. The computing device 302 can thenidentify another gesture that is mapped to that certain applicationfunction, and provide a suggestion for mapping the other gesture to theidentified application function.

In some implementations, the gesture mapping engine 332 can identify afunction the user has controlled previously but is not mapped to agesture, and determine that one or more other users have mapped thefunction, or a similar function, to a particular physical motiongesture. The gesture mapping engine 332 can then identify the particularphysical motion gesture for the suggestion engine 330, so that thesuggestion engine 330 can cause the computing device, or anothercomputing device, to provide a suggestion to the user for mapping theparticular physical motion gesture to the identified function. Forinstance, the computing device 302 can access a remote computing device,such as a server device, which can identify physical motion gesturesthat others user perform to control certain application functions. Thegesture mapping engine 332 can then identify the gesture that the otherusers are commonly using to control that certain application functionand cause the suggestion engine 330 to recommend that that gesture forthe user to map to the identified function.

In some implementations, the gesture mapping engine 332 can map aphysical motion gesture to a function of an application and/or anothercomputing device 338 based on the automated assistant 308 recognizingthat the user performed a gesture one or more times within a time periodthat the user also controlled the function of the application. Forinstance, with prior permission from the user, an assistant interface304, such as a camera, can capture image data that characterizes theuser at least attempting to perform a physical motion gesture.Furthermore, the automated assistant 308 can determine that the user hascontrolled a particular function of another computing device 338, withina time period of performing the physical motion gesture. For example,the time period can be 5 seconds before controlling the particularfunction and/or 5 seconds after controlling the particular function.Therefore, if the user performs the physical motion gesture one or moretimes within 3 seconds of controlling the function, the gesture mappingengine 332 can map the physical motion gesture to the particularfunction.

In some implementations, the user can be prompted to confirm that theuser would like the physical motion gesture to be mapped to the functionof an application that is accessible via another computing device 338.For instance, the gesture mapping engine 332 can confirm that that theuser performed a physical motion gesture one or more times within a timeperiod of controlling the function, and then communicate this occurrenceto the suggestion engine 330. In response, the suggestion engine 330 cancause the computing device 302 to provide a graphical element thatincludes a request for the user to confirm whether the physical motiongesture they performed should be mapped to the function that theycontrolled recently. If the user confirms, the suggestion engine 330 cancommunicate this confirmation to the gesture mapping engine 332, whichgenerate data characterizing and/or establishing the mapping of thephysical motion gesture to the function of the application.

FIGS. 4A and 4B illustrate a method 400 and a method 420 for mapping oneor more physical motion gestures to one or more functions, accessiblevia one or more devices and/or one or more applications. The method 400and the method 420 can be performed together, or separately. The method400 and/or the method 420 can be performed by one or more applications,computing devices, and/or any other apparatus or module capable ofresponding to a user input. The method 400 can include an operation 402of determining whether a physical motion gesture has been detected atone or more computing device interfaces. A computing device interfacecan include any interface with which a user can provide an input to acomputing device. For instance the computing device interface caninclude a camera interface, which can generate an output thatcharacterizes a physical motion gesture that is performed by a user. Theoutput of the camera interface can be used to generate image data fromwhich the operation 402 can be determined. For example, when the userhas not performed a physical motion gesture, the image data will notindicate that the user performed a physical motion gesture, andtherefore the method 400 can proceed from the operation 402 to anoperation 424, according to continuation element “C.” The continuationelement “C” can represent a continuation between the method 400 and themethod 420, and the continuation can be from the operation 402 to theoperation 424, and/or from the operation 424 to the operation 402.

The operation 424 can include determining that a function (or anotherfunction) controlled by the user. If a function (or another function)has not been controlled by the user, the method 420 can return to theoperation 402 via the continuation element “C.” However, if the functionhas been controlled by the user, the method 420 can proceed from theoperation 424 to the operation 426. Similarly, if a physical motiongesture is detected at the operation 402, the method 400 can proceedfrom the operation 402 to the operation 404.

The operation 404 can include identifying a gesture intended by theuser. In order to identify the gesture intended by the user, image datathat captures the physical motion gesture performed by the user can beprocessed. In some implementations, the image data can be applied to oneor more trained machine learning models, and a gesture can be identifiedbased on the one or more trained machine learning models. Alternatively,or additionally, the image data can be compared to existing datacharacterizing one or more different available gestures, and, based onthe comparing, determine that the identified gesture is one of the oneor more different available gestures. When the intended gesture isidentified at operation 404, the method 400 can proceed to an operation406.

The operation 406 can include determining whether the intended gestureis mapped to a function. In other words, a determination is made as towhether there is any data that correlates the intended gesture to afunction, which can be otherwise controllable via a computing deviceand/or an application. If the intended gesture is mapped to a function,the method 400 can proceed from the operation 406 to the operation 414.At the operation 414, the function can be controlled according to theintended gesture. For example, the function can be executed, modified,and/or stopped depending on how the gesture is mapped to the particularfunction, and/or how the function is configured.

When the intended gesture is not mapped to a function, the method 400can proceed from the operation 406 to the operation 408. The operation408 can include identifying one or more functions not currently mappedto a particular gesture. In this way, the method 400 ensures that theintended gesture is not mapped to a function that is already correlatedto a gesture, unless the user is explicitly requesting such aconfiguration. The one or more functions not mapped to a particulargesture can be identified from functions that the user has controlledpreviously, functions that are accessible via one or more applicationsand/or one or more computing devices associated with the user, and/orany other functions that can be mapped to a particular gesture. When oneor more functions that are not mapped to a particular gesture areidentified at the operation 408, the method 400 can proceed to theoperation 410.

The operation 410 can include analyzing the one or more functions.Analyzing the one or more identified functions can include determiningparameters for the one or more functions. Alternatively, oradditionally, analyzing the one or more functions can includedetermining a frequency of use of the one or more functions by the user,and/or other users. Alternatively, or additionally, analyzing the one ormore functions can include determining a frequency of use of a computingdevice and/or an application with which the user has accessed and/orcontrolled the one or more functions. In some implementations, theoperation 410 can include prompting the user to verify whether theywould like the identify gesture to be mapped to a particular function ofthe one or more identified functions. When the user confirms, theintended gesture can be mapped to the particular function.

The method 400 can proceed from the operation 410 to the operation 412,which can include mapping the intended gesture to a function of theidentified one or more functions. In this way if the user subsequentlyperforms an instance of the identified gesture, the particular functioncan be controlled according to the mapping at operation 412. Therefore,if the mapping of the intended gesture to the particular functionincludes executing the particular function when the intended gesture isperformed, the user's subsequent performance of the intended gesturewill cause execution of a particular function (e.g., muting a microphoneduring a phone call).

Optionally, the method 400 can proceed from the operation 412 to anoptional operation 416. The optional operation 416 can includedetermining whether other related functions have not been mapped toanother gesture. For example, a determination can be made as to whetherthere are any other functions of an application corresponding to therecently mapped function, and whether any of those other functions havealso been mapped to any other gestures. If there is another functionthat has not been mapped to a particular gesture, a suggestion can beprovided to the user for confirming where the user would like anotherfunction mapped to another gesture. If the user would like anotherfunction mapped to another gesture, the method 400 can proceed to themethod 420, via continuation element “D,” which is continues to anoperation 428 of the method 420.

When the method 400 transitions from operation 402, to the operation424, a determination can be made as to whether another function has beencontrolled by the user. The method 420 can then proceed from theoperation 424 to the operation 426. The operation 426 can includedetermining whether a particular function (e.g., a function recentlycontrolled by the user) has been mapped to a particular gesture. If afunction that has been recently controlled by a user is mapped to aparticular gesture already, the method 420 can proceed from theoperation 426 back to the operation 424, where a computing device canawait control, by a user(s), of another function, or continue viacontinuation element “C” to the operation 402. However, if theparticular function controlled by the user has not been mapped to aparticular gesture, the method 420 can proceed to an operation 428.

The operation 428 can include determining whether the user performed amotion within a threshold period of time of controlling the function.Determining whether user performed a motion can include determiningwhether the user performed a motion that is discernible as a physicalmotion gesture, and that is different from frequent motions that are nottypically intended to trigger an application action and/or a computingdevice action. For instance, determining whether the user performed amotion can include determining whether the user performed at least aportion of an available gesture, which the user previously had notperformed before, but that is otherwise capable of being used to controlan application and/or a computing device associated with the user. Ifthe user performed a “motion” within the threshold period of time ofcontrolling the function, the method 420 can proceed from the operation428 to the operation 434. The operation 434 can including creating agesture from the motion, which was performed by the user, and mappingthe created gesture to the function that was controlled by the user. Themethod 420 can then proceed from the operation 434, via continuationelement “E,” to the operation 416.

However, if the user did not perform a motion within the thresholdperiod of time of controlling the function, the method 420 can proceedfrom the operation 428 to the operation 430. The operation 430 caninclude identifying a candidate gesture for mapping to the function thatwas controlled by the user (and/or another function that will besuggested for mapping to an identified gesture—if continuing fromcontinuation element “D”). Candidate gestures for mapping to thefunction can include: gestures that the user has performed previously,gestures that include the same motion that the user performed (e.g. themotion identified at operation 428), gestures that other users performedto control the function, a gesture that has been newly assigned by amanufacturer to the function, and/or any other gestures that a computingdevice can be responsive to.

When a gesture for mapping to the function is identified, the method 420can proceed from the operation 430 to the operation 432. The operation432 can include mapping the identified gesture to the functioncontrolled by the user, or any other function that has been identifiedduring performance of the method 400 and/or the method 420. The method420 can then proceed from the operation 432, via the continuationelement “E,” to the operation 416.

FIG. 5 is a block diagram of an example computer system 510. Computersystem 510 typically includes at least one processor 514 whichcommunicates with a number of peripheral devices via bus subsystem 512.These peripheral devices may include a storage subsystem 524, including,for example, a memory 525 and a file storage subsystem 526, userinterface output devices 520, user interface input devices 522, and anetwork interface subsystem 516. The input and output devices allow userinteraction with computer system 510. Network interface subsystem 516provides an interface to outside networks and is coupled tocorresponding interface devices in other computer systems.

User interface input devices 522 may include a keyboard, pointingdevices such as a mouse, trackball, touchpad, or graphics tablet, ascanner, a touchscreen incorporated into the display, audio inputdevices such as voice recognition systems, microphones, and/or othertypes of input devices. In general, use of the term “input device” isintended to include all possible types of devices and ways to inputinformation into computer system 510 or onto a communication network.

User interface output devices 520 may include a display subsystem, aprinter, a fax machine, or non-visual displays such as audio outputdevices. The display subsystem may include a cathode ray tube (CRT), aflat-panel device such as a liquid crystal display (LCD), a projectiondevice, or some other mechanism for creating a visible image. Thedisplay subsystem may also provide non-visual display such as via audiooutput devices. In general, use of the term “output device” is intendedto include all possible types of devices and ways to output informationfrom computer system 510 to the user or to another machine or computersystem.

Storage subsystem 524 stores programming and data constructs thatprovide the functionality of some or all of the modules describedherein. For example, the storage subsystem 524 may include the logic toperform selected aspects of method 400, method 420, and/or to implementone or more of first computing device 102, second computing device 134,first computing device 208, second computing device 202, third computingdevice 214, computing device 302, automated assistant 308, gesturemapping engine 332, suggestion engine 330, trained machine learningmodels 328, other computing device(s) 338, and/or any other device,operation, application, and/or engine discussed herein.

These software modules are generally executed by processor 514 alone orin combination with other processors. Memory 525 used in the storagesubsystem 524 can include a number of memories including a main randomaccess memory (RAM) 530 for storage of instructions and data duringprogram execution and a read only memory (ROM) 532 in which fixedinstructions are stored. A file storage subsystem 526 can providepersistent storage for program and data files, and may include a harddisk drive, a floppy disk drive along with associated removable media, aCD-ROM drive, an optical drive, or removable media cartridges. Themodules implementing the functionality of certain implementations may bestored by file storage subsystem 526 in the storage subsystem 524, or inother machines accessible by the processor(s) 514.

Bus subsystem 512 provides a mechanism for letting the variouscomponents and subsystems of computer system 510 communicate with eachother as intended. Although bus subsystem 512 is shown schematically asa single bus, alternative implementations of the bus subsystem may usemultiple busses.

Computer system 510 can be of varying types including a workstation,server, computing cluster, blade server, server farm, or any other dataprocessing system or computing device. Due to the ever-changing natureof computers and networks, the description of computer system 510depicted in FIG. 5 is intended only as a specific example for purposesof illustrating some implementations. Many other configurations ofcomputer system 510 are possible having more or fewer components thanthe computer system depicted in FIG. 5.

In situations in which the systems described herein collect personalinformation about users (or as often referred to herein,“participants”), or may make use of personal information, the users maybe provided with an opportunity to control whether programs or featurescollect user information (e.g., information about a user's socialnetwork, social actions or activities, profession, a user's preferences,or a user's current geographic location), or to control whether and/orhow to receive content from the content server that may be more relevantto the user. Also, certain data may be treated in one or more waysbefore it is stored or used, so that personal identifiable informationis removed. For example, a user's identity may be treated so that nopersonal identifiable information can be determined for the user, or auser's geographic location may be generalized where geographic locationinformation is obtained (such as to a city, ZIP code, or state level),so that a particular geographic location of a user cannot be determined.Thus, the user may have control over how information is collected aboutthe user and/or used.

While several implementations have been described and illustratedherein, a variety of other means and/or structures for performing thefunction and/or obtaining the results and/or one or more of theadvantages described herein may be utilized, and each of such variationsand/or modifications is deemed to be within the scope of theimplementations described herein. More generally, all parameters,dimensions, materials, and configurations described herein are meant tobe exemplary and that the actual parameters, dimensions, materials,and/or configurations will depend upon the specific application orapplications for which the teachings is/are used. Those skilled in theart will recognize, or be able to ascertain using no more than routineexperimentation, many equivalents to the specific implementationsdescribed herein. It is, therefore, to be understood that the foregoingimplementations are presented by way of example only and that, withinthe scope of the appended claims and equivalents thereto,implementations may be practiced otherwise than as specificallydescribed and claimed. Implementations of the present disclosure aredirected to each individual feature, system, article, material, kit,and/or method described herein. In addition, any combination of two ormore such features, systems, articles, materials, kits, and/or methods,if such features, systems, articles, materials, kits, and/or methods arenot mutually inconsistent, is included within the scope of the presentdisclosure.

1. A method implemented by one or more processors, the methodcomprising: determining, based on data generated in response to agesture input to a computing device, that a user has performed aparticular gesture that the user has not previously provided as an inputto the computing device; determining, based on the data, that a separategesture input was previously provided a separate computing device by adifferent user, and that the separate gesture input has one or morecharacteristics in common with the gesture input provided by the user tothe computing device, wherein the separate gesture input was previouslyprovided to the separate computing device to control an applicationfunction of the separate computing device; causing, in response todetermining that the separate gesture input has one or morecharacteristics in common with the gesture input, an interface of thecomputing device or another computing device to provide a request to theuser to confirm whether the user intended the gesture input to imitatethe separate gesture input; in response receiving a user input thatindicates the user intended the gesture input to imitate the separategesture input responsive to the request: determining that anotherapplication function is controllable via the computing device and thatthe other application function includes a common feature to theapplication function, and causing the application function to becontrollable via an instance of the gesture input.
 2. The method ofclaim 1, further comprising: in response receiving a user input thatindicates the user did not intend the gesture input to imitate theseparate gesture input responsive to the request: identifying one ormore applications functions that are controllable via the computingdevice, and prompting the user to select a particular applicationfunction of the one or more application functions to be controllable viathe gesture input.
 3. The method of claim 2, further comprising: inresponse receiving a user input that indicates the user did not intendthe gesture input to imitate the separate gesture input responsive tothe request: determining, that the user has selected the particularapplication function of the one or more application functions to becontrollable via the gesture input, and causing the interface of thecomputing device or the other computing device to provide anotherrequest for the user to perform another instance of the gesture input.4. The method of claim 1, wherein the common feature is a commonparameter, and causing the application function to be controllable viathe instance of the gesture input includes causing a parameter value tobe assigned to the common parameter when the user subsequently performsthe instance of the gesture input.
 5. The method of claim 1, whereindetermining that the another application function is controllable viathe computing device comprises: identifying an application, frommultiple different applications, that the user has previously controlledwithout providing a physical motion gesture to a camera interface of thecomputing device, and determining one or more different applicationfunctions that are controllable via the application, wherein the one ormore different application functions include the application function.6. A method implemented by one or more processors, the methodcomprising: determining, based on processing image data captured via acamera interface of a computing device from which one or moreapplications are accessible, that a user has performed a physical motiongesture one or more times, wherein the one or more applications areresponsive to other physical motion gestures and the one or moreapplications are currently unresponsive to the physical motion gesture;determining that the user has caused an action to be performed, via anapplication of the one or more applications, and within a period of timeof the user performing the physical motion gesture one or more times;causing, in response to determining that the user caused the action tobe performed via the application, an interface of the computing deviceor another computing device to provide a request to the user to confirmwhether the user intended the physical motion gesture to control theaction performed via the application; in response receiving a user inputthat indicates the user did not intended the physical motion gesture tocontrol the action performed by the application: generating control datathat indicates the action performed by the application is controllablevia an instance of the physical motion gesture.
 7. The method of claim6, wherein determining that the user has performed the physical motiongesture one or more times includes: determining that the image data,and/or gesture data characterizing the performance of the physicalmotion gesture by the user, is associated with other data thatcorresponds to a particular physical motion gesture of one or more otherphysical motion gestures.
 8. The method of claim 7, wherein theparticular physical motion gesture is associated with another user thatconfigured another computing device and/or another application to beresponsive to the particular physical motion gesture.
 9. The method ofclaim 8, wherein the other data, which corresponds to the particularphysical motion gesture, is generated based on each user, of multipledifferent users, performing an instance of the particular physicalmotion gesture.
 10. The method of claim 6, wherein the period of time isbased on an action type corresponding to the action performed via theapplication and/or is based on an application type corresponding to theapplication.
 11. The method of claim 6, wherein the request provided tothe user to confirm whether the user intended the physical motiongesture to control the action performed via the application includesproviding a request for the user to perform another instance of thephysical motion gesture in order to indicate confirmation.
 12. Themethod of claim 6, further comprising: identifying another function ofthe application that is not currently responsive to another physicalmotion gesture captured via the camera interface of the computingdevice; and when the user confirms they intended the physical motiongesture to control the action performed by the application: causing theinterface of the computing device to provide another request forpermission from the user to allow the other function to be controllablevia the other physical motion gesture.
 13. A system comprising: at leastone processor; and memory storing instructions that, when executed,cause the at least one processor to perform operations, the operationscomprising: determining, based on data generated in response to agesture input to a computing device, that a user has performed aparticular gesture that the user has not previously provided as an inputto the computing device; determining, based on the data, that a separategesture input was previously provided a separate computing device by adifferent user, and that the separate gesture input has one or morecharacteristics in common with the gesture input provided by the user tothe computing device, wherein the separate gesture input was previouslyprovided to the separate computing device to control an applicationfunction of the separate computing device; causing, in response todetermining that the separate gesture input has one or morecharacteristics in common with the gesture input, an interface of thecomputing device or another computing device to provide a request to theuser to confirm whether the user intended the gesture input to imitatethe separate gesture input; in response receiving a user input thatindicates the user intended the gesture input to imitate the separategesture input responsive to the request: determining that anotherapplication function is controllable via the computing device and thatthe other application function includes a common feature to theapplication function, and causing the application function to becontrollable via an instance of the gesture input.
 14. The system ofclaim 13, the operations further comprising: in response receiving auser input that indicates the user did not intend the gesture input toimitate the separate gesture input responsive to the request:identifying one or more applications functions that are controllable viathe computing device, and prompting the user to select a particularapplication function of the one or more application functions to becontrollable via the gesture input.
 15. The system of claim 14, theoperations further comprising: in response receiving a user input thatindicates the user did not intend the gesture input to imitate theseparate gesture input responsive to the request: determining, that theuser has selected the particular application function of the one or moreapplication functions to be controllable via the gesture input, andcausing the interface of the computing device or the other computingdevice to provide another request for the user to perform anotherinstance of the gesture input.
 16. The system of claim 13, wherein thecommon feature is a common parameter, and causing the applicationfunction to be controllable via the instance of the gesture inputincludes causing a parameter value to be assigned to the commonparameter when the user subsequently performs the instance of thegesture input.
 17. The system of claim 13, wherein determining that theanother application function is controllable via the computing devicecomprises: identifying an application, from multiple differentapplications, that the user has previously controlled without providinga physical motion gesture to a camera interface of the computing device,and determining one or more different application functions that arecontrollable via the application, wherein the one or more differentapplication functions include the application function.